home *** CD-ROM | disk | FTP | other *** search
/ Reverse Code Engineering RCE CD +sandman 2000 / ReverseCodeEngineeringRceCdsandman2000.iso / RCE / Ebooks / Thinking in C++ V2 / C25 / Recycle1.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2000-05-25  |  3.0 KB  |  128 lines
  1. //: C25:Recycle1.cpp 
  2. // From Thinking in C++, 2nd Edition
  3. // Available at http://www.BruceEckel.com
  4. // (c) Bruce Eckel 1999
  5. // Copyright notice in Copyright.txt
  6. // Recycling with RTTI
  7. #include "sumValue.h"
  8. #include "../purge.h"
  9. #include <fstream>
  10. #include <vector>
  11. #include <typeinfo>
  12. #include <cstdlib>
  13. #include <ctime>
  14. using namespace std;
  15. ofstream out("Recycle1.out");
  16.  
  17. class Trash {
  18.   double _weight;
  19.   static int _count; // # created
  20.   static int _dcount; // # destroyed
  21.   // disallow automatic creation of
  22.   // assignment & copy-constructor:
  23.   void operator=(const Trash&);
  24.   Trash(const Trash&);
  25. public:
  26.   Trash(double wt) : _weight(wt) { 
  27.     _count++; 
  28.   }
  29.   virtual double value() const = 0;
  30.   double weight() const { return _weight; }
  31.   static int count() { return _count; }
  32.   static int dcount() { return _dcount;}
  33.   virtual ~Trash() { _dcount++; }
  34. };
  35.  
  36. int Trash::_count = 0;
  37. int Trash::_dcount = 0;
  38.  
  39. class Aluminum : public Trash {
  40.   static double val;
  41. public:
  42.   Aluminum(double wt) : Trash(wt) {}
  43.   double value() const { return val; }
  44.   static void value(double newval) {
  45.     val = newval;
  46.   }
  47.   ~Aluminum() { out << "~Aluminum\n"; }
  48. };
  49.  
  50. double Aluminum::val = 1.67F;
  51.  
  52. class Paper : public Trash {
  53.   static double val;
  54. public:
  55.   Paper(double wt) : Trash(wt) {}
  56.   double value() const { return val; }
  57.   static void value(double newval) {
  58.     val = newval;
  59.   }
  60.   ~Paper() { out << "~Paper\n"; }
  61. };
  62.  
  63. double Paper::val = 0.10F;
  64.  
  65. class Glass : public Trash {
  66.   static double val;
  67. public:
  68.   Glass(double wt) : Trash(wt) {}
  69.   double value() const { return val; }
  70.   static void value(double newval) {
  71.     val = newval;
  72.   }
  73.   ~Glass() { out << "~Glass\n"; }
  74. };
  75.  
  76. double Glass::val = 0.23F;
  77.  
  78. class TrashGen {
  79. public:
  80.   TrashGen() { srand(time(0)); }
  81.   static double frand(int mod) {
  82.     return static_cast<double>(rand() % mod);
  83.   }
  84.   Trash* operator()() {
  85.     for(int i = 0; i < 30; i++)
  86.       switch(rand() % 3) {
  87.         case 0 :
  88.           return new Aluminum(frand(100));
  89.         case 1 :
  90.           return new Paper(frand(100));
  91.         case 2 :
  92.           return new Glass(frand(100));
  93.       }
  94.     return new Aluminum(0);
  95.     // Or throw exeception...
  96.   }
  97. };
  98.  
  99. int main() {
  100.   vector<Trash*> bin;
  101.   // Fill up the Trash bin:
  102.   generate_n(back_inserter(bin), 30, TrashGen());
  103.   vector<Aluminum*> alBin;
  104.   vector<Paper*> paperBin;
  105.   vector<Glass*> glassBin;
  106.   vector<Trash*>::iterator sorter = bin.begin();
  107.   // Sort the Trash:
  108.   while(sorter != bin.end()) {
  109.     Aluminum* ap = 
  110.       dynamic_cast<Aluminum*>(*sorter);
  111.     Paper* pp = dynamic_cast<Paper*>(*sorter);
  112.     Glass* gp = dynamic_cast<Glass*>(*sorter);
  113.     if(ap) alBin.push_back(ap);
  114.     if(pp) paperBin.push_back(pp);
  115.     if(gp) glassBin.push_back(gp);
  116.     sorter++;
  117.   }
  118.   sumValue(alBin);
  119.   sumValue(paperBin);
  120.   sumValue(glassBin);
  121.   sumValue(bin);
  122.   out << "total created = "
  123.       << Trash::count() << endl;
  124.   purge(bin);
  125.   out << "total destroyed = "
  126.       << Trash::dcount() << endl;
  127. } ///:~
  128.